ECE 5725 Coivd Access Control System

# import the necessary packages
from tensorflow.keras.applications.mobilenet_v2 import preprocess_input
from tensorflow.keras.preprocessing.image import img_to_array
from tensorflow.keras.models import load_model
from imutils.video import VideoStream
import pygame # Import pygame graphics library
import os #for OS calls
import RPi.GPIO as GPIO
from sys import exit
import numpy as np
import argparse
import imutils
import time
import cv2
import os
import datetime
from smbus2 import SMBus
from mlx90614 import MLX90614
import binascii
import serial
import serial.tools.list_ports
import time
import MySQLdb
import threading
#database

os.putenv('SDL_FBDEV','/dev/fb1')
os.putenv('SDL_VIDEODRIVER', 'fbcon') # Display on piTFT


def recog(n):
    #initial welcom page
    #initizlize pygame:
    print(n)
    global Temp
    Temp = False
    def check():
        global Faver
        global doCheck
        Faver = False
        doCheck = False
        temp_sum = 0
        total = 0
        print("Initializing Body Temerature module")
        ###show on PiTFT
        my_font = pygame.font.Font(None, 20)
        my_message = {"Initializing Body Temerature module":(160,150)}
        screen.fill(black)
        for my_text, text_pos in my_message.items():
            text_surface = my_font.render(my_text, True, WHITE)
            rect = text_surface.get_rect(center=text_pos)
            screen.blit(text_surface,rect)
        ballrect.center = (160,110)
        screen.blit(ball,ballrect) 
        pygame.display.flip()
        time.sleep(1)
            
        bus = SMBus(1)
        sensor = MLX90614(bus, address=0x5A)

        print("Please bring your forehead near Sensor 1")
            ###show on PiTFT
        my_font = pygame.font.Font(None, 20)
        my_message = {"Please bring your forehead near Sensor 1":(160,150), "This might take about 3s":(160,170)}
        screen.fill(black)
        for my_text, text_pos in my_message.items():
            text_surface = my_font.render(my_text, True, WHITE)
            rect = text_surface.get_rect(center=text_pos)
            screen.blit(text_surface,rect)
        ballrect.center = (160,110)
        screen.blit(ball,ballrect) 
        pygame.display.flip()
        time.sleep(3)


        print("Measurement start in 1s")
            ###show on PiTFT
        my_font = pygame.font.Font(None, 20)
        my_message = {"Measuring":(160,150)}
        screen.fill(black)
        for my_text, text_pos in my_message.items():
            text_surface = my_font.render(my_text, True, WHITE)
            rect = text_surface.get_rect(center=text_pos)
            screen.blit(text_surface,rect)
        ballrect.center = (160,110)
        screen.blit(ball,ballrect) 
        pygame.display.flip()
        time.sleep(1)

        t_end_2 = time.time() + 3
        while time.time() < t_end_2:
            #print ("Object Temperature: ", sensor.get_object_1())
            total = total + 1
            temp_sum = temp_sum + sensor.get_object_1()
            
        body_temp = temp_sum/total    
        print('Your temperature is: ', body_temp)
        if body_temp > 35:
            print("You are having a fever")
                ###show on PiTFT
            my_font = pygame.font.Font(None, 20)
            my_message = {"You are having a fever":(160,150), "Door Remains Closed":(160,170)}
            screen.fill(black)
            for my_text, text_pos in my_message.items():
                text_surface = my_font.render(my_text, True, WHITE)
                rect = text_surface.get_rect(center=text_pos)
                screen.blit(text_surface,rect)
            ballrect.center = (160,110)
            screen.blit(ball,ballrect) 
            pygame.display.flip()
            time.sleep(3)
            
            Faver = True
            doCheck = False
            #print (bool(Faver))
            return True
        
        elif body_temp < 25:
            print("Remeasuring")
                ###show on PiTFT
            my_font = pygame.font.Font(None, 20)
            my_message = {"Pease bring your forehead closer":(160,150)}
            screen.fill(black)
            for my_text, text_pos in my_message.items():
                text_surface = my_font.render(my_text, True, WHITE)
                rect = text_surface.get_rect(center=text_pos)
                screen.blit(text_surface,rect)
            ballrect.center = (160,110)
            screen.blit(ball,ballrect) 
            pygame.display.flip()
            time.sleep(2)
            doCheck = True
            return False
        
        else:
            print("Normal")
                    ###show on PiTFT
            my_font = pygame.font.Font(None, 20)
            my_message = {"Normal":(160,150)}
            screen.fill(black)
            for my_text, text_pos in my_message.items():
                text_surface = my_font.render(my_text, True, WHITE)
                rect = text_surface.get_rect(center=text_pos)
                screen.blit(text_surface,rect)
            ballrect.center = (160,110)
            screen.blit(ball,ballrect) 
            pygame.display.flip()
            time.sleep(2)
            doCheck = False
            return True
            # temp ans mask ok
    def detect_and_predict_mask(frame, faceNet, maskNet):
        # grab the dimensions of the frame and then construct a blob
        # from it
        (h, w) = frame.shape[:2]
        blob = cv2.dnn.blobFromImage(frame, 1.0, (300, 300),
            (104.0, 177.0, 123.0))

        # pass the blob through the network and obtain the face detections
        faceNet.setInput(blob)
        detections = faceNet.forward()

        # initialize our list of faces, their corresponding locations,
        # and the list of predictions from our face mask network
        faces = []
        locs = []
        preds = []

        # loop over the detections
        for i in range(0, detections.shape[2]):
            # extract the confidence (i.e., probability) associated with
            # the detection
            confidence = detections[0, 0, i, 2]

            # filter out weak detections by ensuring the confidence is
            # greater than the minimum confidence
            if confidence > args["confidence"]:
                # compute the (x, y)-coordinates of the bounding box for
                # the object
                box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
                (startX, startY, endX, endY) = box.astype("int")

                # ensure the bounding boxes fall within the dimensions of
                # the frame
                (startX, startY) = (max(0, startX), max(0, startY))
                (endX, endY) = (min(w - 1, endX), min(h - 1, endY))

                # extract the face ROI, convert it from BGR to RGB channel
                # ordering, resize it to 224x224, and preprocess it
                face = frame[startY:endY, startX:endX]
                face = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
                face = cv2.resize(face, (224, 224))
                face = img_to_array(face)
                face = preprocess_input(face)

                # add the face and bounding boxes to their respective
                # lists
                faces.append(face)
                locs.append((startX, startY, endX, endY))

        # only make a predictions if at least one face was detected
        if len(faces) > 0:
            # for faster inference we'll make batch predictions on *all*
            # faces at the same time rather than one-by-one predictions
            # in the above `for` loop
            faces = np.array(faces, dtype="float32")
            preds = maskNet.predict(faces, batch_size=32)

        # return a 2-tuple of the face locations and their corresponding
        # locations
        return (locs, preds)
    pygame.init()

    WHITE = 255,255,255
    black = 0,0,0
    size = width,height = 320,240
    screen = pygame.display.set_mode((320,240))

    ball = pygame.image.load("Cornell_1.png")
    ballrect = ball.get_rect()

    my_font = pygame.font.Font(None, 30)
    my_message = {'Covid-Access System':(160,150)}
    for my_text, text_pos in my_message.items():
        text_surface = my_font.render(my_text, True, WHITE)
        rect = text_surface.get_rect(center=text_pos)
        screen.blit(text_surface,rect)
    ballrect.center = (160,110)
    screen.blit(ball,ballrect)    
    pygame.display.flip()             # display workspace on screen
    time.sleep(2)
    # construct the argument parser and parse the arguments
    ap = argparse.ArgumentParser()
    ap.add_argument("-f", "--face", type=str,
        default="face_detector",
        help="path to face detector model directory")
    ap.add_argument("-m", "--model", type=str,
        default="mask_detector.model",
        help="path to trained face mask detector model")
    ap.add_argument("-c", "--confidence", type=float, default=0.5,
        help="minimum probability to filter weak detections")
    args = vars(ap.parse_args())

    # load our serialized face detector model from disk
    print("[INFO] loading face detector model...")
    ### show on PiTFT
    my_font = pygame.font.Font(None, 20)
    my_message = {"[INFO] loading face detector model...":(160,150)}
    screen.fill(black)
    for my_text, text_pos in my_message.items():
        text_surface = my_font.render(my_text, True, WHITE)
        rect = text_surface.get_rect(center=text_pos)
        screen.blit(text_surface,rect)
    ballrect.center = (160,110)
    screen.blit(ball,ballrect) 
    pygame.display.flip()

    prototxtPath = os.path.sep.join([args["face"], "deploy.prototxt"])
    weightsPath = os.path.sep.join([args["face"],
        "res10_300x300_ssd_iter_140000.caffemodel"])
    faceNet = cv2.dnn.readNet(prototxtPath, weightsPath)

    # load the face mask detector model from disk
    print("[INFO] loading face mask detector model...")
    ###show on PiTFT
    my_font = pygame.font.Font(None, 20)
    my_message = {"[INFO] loading face mask detector model...":(160,150)}
    screen.fill(black)
    for my_text, text_pos in my_message.items():
        text_surface = my_font.render(my_text, True, WHITE)
        rect = text_surface.get_rect(center=text_pos)
        screen.blit(text_surface,rect)
    ballrect.center = (160,110)
    screen.blit(ball,ballrect) 
    pygame.display.flip()
    maskNet = load_model(args["model"])

    # initialize the video stream and allow the camera sensor to warm up
    print("Starting video stream...")
    ###show on PiTFT
    my_font = pygame.font.Font(None, 20)
    my_message = {"Starting video stream":(160,150)}
    screen.fill(black)
    for my_text, text_pos in my_message.items():
        text_surface = my_font.render(my_text, True, WHITE)
        rect = text_surface.get_rect(center=text_pos)
        screen.blit(text_surface,rect)
    ballrect.center = (160,110)
    screen.blit(ball,ballrect) 
    pygame.display.flip()
    #vs = VideoStream(src=0).start()
    vs = VideoStream(usePiCamera=True).start()
    time.sleep(2.0)

    global mask_on
    mask_on= False

    global temp_sum
    temp_sum = 0
    


    # loop over the frames from the video stream
    #
    print ("Start to Identify Mask")
    my_font = pygame.font.Font(None, 20)
    my_message = {"Start to Identify Mask":(160,150)}
    speed = [0,0]
    screen.fill(black)
    for my_text, text_pos in my_message.items():
        text_surface = my_font.render(my_text, True, WHITE)
        rect = text_surface.get_rect(center=text_pos)
        screen.blit(text_surface,rect)
    ballrect.center = (160,110)
    screen.blit(ball,ballrect) 
    pygame.display.flip()

    t_end = time.time() + 10
    global hasMask
    hasMask = False
    while not hasMask:
    
        pygame.display.flip()             # display workspace on screen

        # grab the frame from the threaded video stream and resize it
        # to have a maximum width of 400 pixels
        frame = vs.read()
        frame = imutils.resize(frame, width=500)

        # detect faces in the frame and determine if they are wearing a
        # face mask or not
        (locs, preds) = detect_and_predict_mask(frame, faceNet, maskNet)

        # loop over the detected face locations and their corresponding
        # locations
        #print ("Start to Identify Mask")
        for (box, pred) in zip(locs, preds):
            # unpack the bounding box and predictions
            (startX, startY, endX, endY) = box
            (mask, withoutMask) = pred

            # determine the class label and color we'll use to draw
            # the bounding box and text
            if mask > withoutMask:
                #label = "Thank You. Mask On."
                hasMask = True
                print ("Good boy")
                my_font = pygame.font.Font(None, 20)
                my_message = {"Good boy":(160,150)}
                screen.fill(black)
                for my_text, text_pos in my_message.items():
                    text_surface = my_font.render(my_text, True, WHITE)
                    rect = text_surface.get_rect(center=text_pos)
                    screen.blit(text_surface,rect)
                ballrect.center = (160,110)
                screen.blit(ball,ballrect) 
                pygame.display.flip()
                #color = (0, 255, 0)

            else:
                #label = "No Face Mask Detected"
                #color = (0, 0, 255)
                print ("Wear a mask, dummy ", bool(hasMask))
                my_font = pygame.font.Font(None, 20)
                my_message = {"Wear a mask, dummy":(160,150)}
                screen.fill(black)
                for my_text, text_pos in my_message.items():
                    text_surface = my_font.render(my_text, True, WHITE)
                    rect = text_surface.get_rect(center=text_pos)
                    screen.blit(text_surface,rect)
                ballrect.center = (160,110)
                screen.blit(ball,ballrect) 
                pygame.display.flip()
                
                

        
            #label = "Thank you" if mask > withoutMask else "Please wear your face mask"
            #color = (0, 255, 0) if label == "Thank you" else (0, 0, 255)

            # include the probability in the label
            #label = "{}: {:.2f}%".format(label, max(mask, withoutMask) * 100)

            # display the label and bounding box rectangle on the output
            # frame
            #own:
            
            #cv2.putText(frame, label, (startX-50, startY - 10),
                #cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2)
            #cv2.rectangle(frame, (startX, startY), (endX, endY), color, 2)
            

        # show the output frame
        #own:
        #cv2.imshow("Face Mask Detector", frame)
        #key = cv2.waitKey(1) & 0xFF

        # if the `q` key was pressed, break from the loop
        #if key == ord("q"):
            #break

    # do a bit of cleanup
    cv2.destroyAllWindows()
    vs.stop()
    if hasMask is True:
        print ("The visitor is wearing a mask")
        ###show on PiTFT
        my_font = pygame.font.Font(None, 20)
        my_message = {"The visitor is wearing a mask":(160,150)}
        screen.fill(black)
        for my_text, text_pos in my_message.items():
            text_surface = my_font.render(my_text, True, WHITE)
            rect = text_surface.get_rect(center=text_pos)
            screen.blit(text_surface,rect)
        ballrect.center = (160,110)
        screen.blit(ball,ballrect) 
        pygame.display.flip()
        time.sleep(2)
        
        
        while not check() and not Faver:
            print("returning")
        print(Faver)
        if Faver:
            print ("Stops")
            close()
        else:
            #database info check
            print("next")
            global serial
            serial = serial.Serial('/dev/ttyUSB0', 57600, timeout=0.5)  #/dev/ttyUSB0
            def recv(serial):
                while True:
                    data = serial.read_all()
                    if data == '':
                        continue
                    else:
                        break
                return data
            if serial.isOpen() :
                #kaishi caiji zhiwen
                print("Connected with fingure")
                my_font = pygame.font.Font(None, 20)
                my_message = {"Start to Check Student Info":(160,150)}
                speed = [0,0]
                screen.fill(black)
                for my_text, text_pos in my_message.items():
                    text_surface = my_font.render(my_text, True, WHITE)
                    rect = text_surface.get_rect(center=text_pos)
                    screen.blit(text_surface,rect)
                ballrect.center = (160,110)
                screen.blit(ball,ballrect) 
                pygame.display.flip()
                time.sleep(1)
            else :
                print("fail Connected")
            while True:
                a = 'EF 01 FF FF FF FF 01 00 03 01 00 05'
                d = bytes.fromhex(a)
                serial.write(d)
                time.sleep(1)
                data =recv(serial)
                if data != b'' :
                    data_con = str(binascii.b2a_hex(data))[20:22]
                    if(data_con == '02'):
                        #add
                        print("Please put your Fingure")
                        
                        my_font = pygame.font.Font(None, 20)
                        my_message = {"Please Place your Thumb":(160,150)}
                        speed = [0,0]
                        screen.fill(black)
                        for my_text, text_pos in my_message.items():
                            text_surface = my_font.render(my_text, True, WHITE)
                            rect = text_surface.get_rect(center=text_pos)
                            screen.blit(text_surface,rect)
                        ballrect.center = (160,110)
                        screen.blit(ball,ballrect) 
                        pygame.display.flip()
                        time.sleep(1)
                        
                    elif(data_con == '00'):
                        #add
                        print("Loading")
                        my_font = pygame.font.Font(None, 20)
                        my_message = {"Checking Fingureprint Info":(160,150)}
                        speed = [0,0]
                        screen.fill(black)
                        for my_text, text_pos in my_message.items():
                            text_surface = my_font.render(my_text, True, WHITE)
                            rect = text_surface.get_rect(center=text_pos)
                            screen.blit(text_surface,rect)
                        ballrect.center = (160,110)
                        screen.blit(ball,ballrect) 
                        pygame.display.flip()
                        time.sleep(1)
                        
                        buff = 'EF 01 FF FF FF FF 01 00 04 02 01 00 08'
                        buff = bytes.fromhex(buff)
                        serial.write(buff)
                        time.sleep(1)
                        buff_data = recv(serial)
                        buff_con = str(binascii.b2a_hex(buff_data))[20:22]
                        if(buff_con == '00'):
                            #FINISHED
                            
                            my_font = pygame.font.Font(None, 20)
                            my_message = {"Finished Collecting":(160,150)}
                            screen.fill(black)
                            for my_text, text_pos in my_message.items():
                                text_surface = my_font.render(my_text, True, WHITE)
                                rect = text_surface.get_rect(center=text_pos)
                                screen.blit(text_surface,rect)
                            ballrect.center = (160,110)
                            screen.blit(ball,ballrect) 
                            pygame.display.flip()
                            #vs = VideoStream(src=0).start()
                            #vs = VideoStream(usePiCamera=True).start()
                            time.sleep(1.0)
                            
                            serch = 'EF 01 FF FF FF FF 01 00 08 04 01 00 00 00 64 00 72'
                            serch = bytes.fromhex(serch)
                            serial.write(serch)
                            time.sleep(1)
                            serch_data = recv(serial)
                            store = binascii.b2a_hex(serch_data)
                            serch_con = str(store)[20:22]
                            res = str(store)[22:26]
                            print(res)
                          
                            if (serch_con == '09'):
                                #NOT STUDENT
                            
                                print("Sorry you are not cornell student")
                                my_font = pygame.font.Font(None, 20)
                                my_message = {"Sorry, you are not a Cornellian":(160,150), "Door Remains Closed": (160,170)}
                                screen.fill(black)
                                for my_text, text_pos in my_message.items():
                                    text_surface = my_font.render(my_text, True, WHITE)
                                    rect = text_surface.get_rect(center=text_pos)
                                    screen.blit(text_surface,rect)
                                ballrect.center = (160,110)
                                screen.blit(ball,ballrect) 
                                pygame.display.flip()
                                #vs = VideoStream(src=0).start()
                                #vs = VideoStream(usePiCamera=True).start()
                                time.sleep(1.0)
                                
                                
                            elif(serch_con == '00'):
                                conn = MySQLdb.connect(host='192.168.0.16',user='root',passwd='password',db='test13')
                                cursor = conn.cursor()
                                
                                sql = "SELECT * FROM student where fingure = '%s'"%(res)
                                print(sql)
                                cursor.execute(sql)
                                data = cursor.fetchone()
                                print(data)
                                cursor.close()
                                print("we find you")
                                name = data[1]
                                print(name)
                                date = data[2]
                                print(date)
                                my_font = pygame.font.Font(None, 20)
                                my_message = {name:(160,150), date:(160,170)}
                                screen.fill(black)
                                for my_text, text_pos in my_message.items():
                                    text_surface = my_font.render(my_text, True, WHITE)
                                    rect = text_surface.get_rect(center=text_pos)
                                    screen.blit(text_surface,rect)
                                ballrect.center = (160,110)
                                screen.blit(ball,ballrect) 
                                pygame.display.flip()
                                time.sleep(4)
                                
                                covid = data[3]
                                servey = data[4]
                                if covid:
                                    my_font = pygame.font.Font(None, 20)
                                    my_message = {"Covid Negative":(160,150)}
                                    screen.fill(black)
                                    for my_text, text_pos in my_message.items():
                                        text_surface = my_font.render(my_text, True, WHITE)
                                        rect = text_surface.get_rect(center=text_pos)
                                        screen.blit(text_surface,rect)
                                    ballrect.center = (160,110)
                                    screen.blit(ball,ballrect) 
                                    pygame.display.flip()
                                    #vs = VideoStream(src=0).start()
                                    #vs = VideoStream(usePiCamera=True).start()
                                    time.sleep(2.0)
                                    if servey:
                                        print("bu ok")
                                        my_font = pygame.font.Font(None, 20)
                                        my_message = {"Violation of Cornell Conduct Regulation":(160,150), "Please Finish Daily Check":(160,170), "Door Remains Closed":(160,190)}
                                        screen.fill(black)
                                        for my_text, text_pos in my_message.items():
                                            text_surface = my_font.render(my_text, True, WHITE)
                                            rect = text_surface.get_rect(center=text_pos)
                                            screen.blit(text_surface,rect)
                                        ballrect.center = (160,110)
                                        screen.blit(ball,ballrect) 
                                        pygame.display.flip()
                                        #vs = VideoStream(src=0).start()
                                        #vs = VideoStream(usePiCamera=True).start()
                                        time.sleep(4)
                                    else:
                                        #pass
                                        print("ok")
                                        my_font = pygame.font.Font(None, 20)
                                        my_message = {"Welcome In":(160,150), "Door Opens": (160,170)}
                                        screen.fill(black)
                                        for my_text, text_pos in my_message.items():
                                            text_surface = my_font.render(my_text, True, WHITE)
                                            rect = text_surface.get_rect(center=text_pos)
                                            screen.blit(text_surface,rect)
                                        ballrect.center = (160,110)
                                        screen.blit(ball,ballrect) 
                                        pygame.display.flip()
                                        #vs = VideoStream(src=0).start()
                                        vs = VideoStream(usePiCamera=True).start()
                                        time.sleep(2.0)
                                    
                                else:
                                    print("bingle")
                                    my_font = pygame.font.Font(None, 20)
                                    my_message = {"Covid detected":(160,150), "Sorry, we can't let you in":(160, 170)}
                                    screen.fill(black)
                                    for my_text, text_pos in my_message.items():
                                        text_surface = my_font.render(my_text, True, WHITE)
                                        rect = text_surface.get_rect(center=text_pos)
                                        screen.blit(text_surface,rect)
                                    ballrect.center = (160,110)
                                    screen.blit(ball,ballrect) 
                                    pygame.display.flip()
                                    #vs = VideoStream(src=0).start()
                                    #vs = VideoStream(usePiCamera=True).start()
                                    time.sleep(1.0)
                                    
                        serial.close()
                        close()
                        exit()
                    else:
                        close()
                        print("not good")  

    
    

def count(n):
    print(n)
    count = 0;
    while(True):
        if GPIO.input(26):
            count = 0;
            print("0")
        else:
            count = count + 1 
            print(count)
        if(count == 20):
            os.system("shutdown -t 5 now")
            close()
            sys.exit()
        time.sleep(1)



def close():
    GPIO.cleanup
    pygame.quit()
    exit()
if __name__ == "__main__":
    GPIO.setmode(GPIO.BCM)
    GPIO.setwarnings(False)
    GPIO.setup(26,GPIO.IN)
    t1 = threading.Thread(target=count, args=("t1",))
    t2= threading.Thread(target=recog, args=("t2",))
    t1.start()
    t2.start()
    GPIO.cleanup
    pygame.quit()
    exit()